Introduction

● Python Intro

Python Basics

● Basics overview

● Python Variables

● Datatypes

● Python Operators

● Python Type Casting

● Input and Output

● Python comments

Control Statements

● Python if else

● For loops

● For-else Loop

● While loop

● While-else

● Break

● Continue

● Pass

Strings

● String

Lists

● Lists

Tuples

● Tuples

Sets

● Sets

Dictionary

● Dictionary

Arrays

● Python Array

Functions

● Python Functions

✦Assign Function to a Variable

✦Arguments by value and reference

✦Passing function as an argument

✦Returning a function from a function

✦Built-in decorators (@staticmethod, @classmethod)

OOPS

● Python Class

● Inheritance

● Polymorphism

● Abstraction

● Encapsulation

Exception Handling

● Python Exceptions

● Python Logging

✦Variable Data in Logging Message

File Handling

● Python File Handling

Multithreading

● Python Multithreading

Synchronization

● Python Synchronization

Networking

● Python Networking

✦File Transfer with Socket Module

Inbuilt Functions

● Python Function

Reference

● methods

● List

● tuple

● Set

✦symmetric_difference_update()

● dictionary

● string

● array

● modules

● cmath

● collections

✦ChainMap Examples and Recipes

✦namedtuple() Factory Function for Tuples with Named Fields

✦OrderedDict Examples and Recipes

● math

● random

● datetime

✦Determining if an Object is Aware or Naive

✦strftime() and strptime() Behavior

✦strftime() and strptime() Format Codes

● enum

● io

● os

✦Querying the size of a terminal

✦Inheritance of File Descriptors

✦Miscellaneous System Information

● os.path

✦os.path — Common pathname manipulations

● statistics

● threading

✦threading — Thread-based parallelism

● regex

Inheritance → Hybrid Inheritance

Hybrid Inheritance in Python

Hybrid inheritance in Python is a combination of multiple inheritance patterns. It doesn't represent a distinct inheritance type itself, but rather a design where a class inherits from multiple base classes, and at least one of those base classes also employs another inheritance type (like single, multiple, or multilevel). Essentially, it's a "mix-and-match" of different inheritance styles.

Understanding the Components

Before diving into hybrid inheritance, let's review the core inheritance types it builds upon: Single Inheritance: A class inherits from only one parent class.

Single inheritance example class Animal: def speak(self): print("Generic animal sound") class Dog(Animal): def bark(self): print("Woof!") my_dog = Dog() my_dog.speak() my_dog.bark()

Output

Generic animal sound Woof!

Multiple Inheritance: A class inherits from multiple parent classes.

Multiple Inheritance example class Flyer: def fly(self): print("Flying...") class Swimmer: def swim(self): print("Swimming...") class FlyingFish(Flyer, Swimmer): # Inherits from both Flyer and Swimmer pass my_fish = FlyingFish() my_fish.fly() my_fish.swim()

Output

Flying... Swimming...

Multilevel Inheritance: A class inherits from a class that itself inherits from another class (forming a hierarchy).

Multilevel Inheritance example class Mammal: def nurture(self): print("Nurturing young...") class Canine(Mammal): def hunt(self): print("Hunting...") class Wolf(Canine): def howl(self): print("Howling...") my_wolf = Wolf() my_wolf.nurture() my_wolf.hunt() my_wolf.howl()

Output

Nurturing young... Hunting... Howling...

Hybrid Inheritance Examples

Now, let's illustrate hybrid inheritance by combining these: Example 1: Combining Multiple and Single Inheritance

Hybrid inheritance - Combining Multiple and Single Inheritance class Engine: def start(self): print("Engine started") class Car: def drive(self): print("Driving...") class ElectricCar(Car, Engine): # Multiple (Car, Engine) + Single (inheritance from both) def charge(self): print("Charging...") my_ecar = ElectricCar() my_ecar.start() my_ecar.drive() my_ecar.charge()

Output

Engine started Driving... Charging...

Here, `ElectricCar` inherits from both `Car` (single inheritance aspect within the multiple inheritance structure) and `Engine`. This is a simple hybrid scenario.

Example 2: Combining Multilevel and Multiple Inheritance

Hybrid inheritance - Combining Multilevel and Multiple Inheritance class Animal: def eat(self): print("Eating...") class Mammal(Animal): def nurture(self): print("Nurturing young...") class Flyer: def fly(self): print("Flying...") class Bat(Mammal, Flyer): # Multiple (Mammal, Flyer) + Multilevel (Mammal inherits from Animal) def echolocate(self): print("Echolocating...") my_bat = Bat() my_bat.eat() my_bat.nurture() my_bat.fly() my_bat.echolocate()

Output

Eating... Nurturing young... Flying... Echolocating...

In this example, `Bat` inherits from `Mammal` (which itself inherits from `Animal`), and also from `Flyer`. This combines multilevel inheritance (in `Mammal`) with multiple inheritance (in `Bat`).

Example 3: A More Complex Scenario

Hybrid example in python class Vehicle: def move(self): print("Moving...") class LandVehicle(Vehicle): def drive(self): print("Driving on land...") class WaterVehicle(Vehicle): def sail(self): print("Sailing on water...") class AmphibiousVehicle(LandVehicle, WaterVehicle): # Multiple + Multilevel (implicit through Vehicle) def switchMode(self): print("Switching modes...") my_amphib = AmphibiousVehicle() my_amphib.move() my_amphib.drive() my_amphib.sail() my_amphib.switchMode()

Output

Moving... Driving on land... Sailing on water... Switching modes...

This demonstrates a more complex hierarchy, illustrating how multiple inheritance can be combined with implicit multilevel inheritance through a common ancestor (`Vehicle`).

Method Resolution Order (MRO)

Python's MRO, typically using C3 linearization, determines the order in which methods are resolved in the case of inheritance conflicts (when multiple parent classes have methods with the same name). You can check the MRO using `__mro__` attribute or `help(ClassName)`. Understanding MRO is crucial for correctly predicting the behavior of hybrid inheritance scenarios. Hybrid inheritance allows for flexible and powerful class designs, enabling you to model complex relationships effectively. However, it also increases the complexity of code, requiring careful attention to method resolution and potential conflicts. Always carefully consider the design implications before employing hybrid inheritance.

Tutorials